package com.xxl.job.executor.service;

import com.xxl.job.executor.utils.StringUtil;
import com.xxl.job.executor.utils.ThreadLocalDateUtil;
import org.springframework.stereotype.Service;


/**
 * 判断信号是否可存入redis
 */
@Service
public class CheckSaveRedisService {


    /**
     *
     * @param currValue 当前采集值
     * @param currTime 当前采集时间
     * @param lastValue 上次采集值
     * @param lastTime 上次采集时间
     * @param delta 采集敏感度
     * @param abnormal 异常敏感度
     * @param uplimit 控制上限
     * @param lwlimit 控制下限
     * @return true 满足存储条件  false不满足存储条件
     */
    private boolean isSaveRedis(String currValue,String currTime,String lastValue,String lastTime,
                                String delta,String abnormal,String uplimit,String lwlimit){
        Double fTmp,fa,fUp,fLw,fAb;
        long iTimeDiffHour=0;
        if(!StringUtil.checkNum(currValue)){//不是数字,状态量
            if(lastValue!=null&&lastValue.length()>0){//redis已存在该信号实时数据
                if(currValue.equals(lastValue)&&
                        (ThreadLocalDateUtil.parse(currTime).getTime() - ThreadLocalDateUtil.parse(lastTime).getTime()) / (1000 * 60 * 60)<=1){//两次采集值相同并且间隔时间小于等于1小时
                    return false;
                }else{
                    return true;
                }
            }else{//redis不存在该信号实时数据，第一次存储
                return true;
            }
        }
        //模拟量
        if(lastValue != null&&lastValue.length()>0){//redis已存在该信号实时数据
            fa = Double.parseDouble(currValue) - Double.parseDouble(lastValue);
            iTimeDiffHour = (ThreadLocalDateUtil.parse(currTime).getTime() - ThreadLocalDateUtil.parse(lastTime).getTime()) / (1000 * 60 * 60);
        }else{//redis不存在该信号实时数据，第一次存储
            fa = Double.parseDouble(currValue);
            iTimeDiffHour = ThreadLocalDateUtil.parse(currTime).getTime() / (1000 * 60 * 60);
        }
        fa = (fa < 0) ? -fa : fa;

        if(delta == null||"".equals(delta)){//判断采集敏感度
            fTmp = Double.valueOf(0);
        }else{
            fTmp = Double.parseDouble(delta);
        }

        if(uplimit == null||"".equals(uplimit)){//判断控制上限
            fUp = Double.valueOf(0);
        }else{
            fUp = Double.parseDouble(uplimit);
        }

        if(lwlimit == null||"".equals(lwlimit)){//判断控制下限
            fLw = Double.valueOf(0);
        }else {
            fLw = Double.parseDouble(lwlimit);
        }

        if(abnormal == null||"".equals(abnormal)){//判断异常敏感度
            fAb = Double.valueOf(0);
        }else {
            fAb = Double.parseDouble(abnormal);
        }

        double modelVal= Double.parseDouble(currValue);
        //两次采集的数值差大于采集敏感度并且当前数值小于等于控制上限并且当前数值大于等于控制下限
        //或者两次采集的数值差大于异常敏感度并且当前数值大于控制上限
        //或者两次采集的数值差小于异常敏感度并且当前数值小于控制下限
        //或者两次采集的时间差大于一小时
        if ((fa > fTmp && modelVal<= fUp && modelVal >= fLw)
                || (fa > fAb && modelVal > fUp)
                || (fa > fAb && modelVal < fLw)
                || iTimeDiffHour > 1) {
            return true;
        }
        return false;
    }



}
